package org.whh.automatic.ui;

import org.whh.automatic.model.AutoTask;
import org.whh.automatic.model.Step;
import org.whh.automatic.service.AutoTaskService;
import org.whh.automatic.ui.dialog.DialogManager;
import org.whh.automatic.util.StepDialogUIUtil;

import javax.swing.*;
import javax.swing.filechooser.FileNameExtensionFilter;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.io.File;
import java.io.Serial;

/**
 * 任务编辑对话框
 * <p>
 * 该对话框用于创建和编辑自动化任务，提供以下功能：
 * 1. 基本信息设置：
 * - 任务名称
 * - 启动文件路径（支持文件浏览）
 * 2. 步骤管理：
 * - 添加步骤
 * - 编辑步骤
 * - 删除步骤
 * - 调整步骤顺序（上移/下移）
 * 3. 坐标捕获：
 * - 批量捕获未设置坐标的步骤
 * - 重新捕获选中步骤的坐标
 * <p>
 * 界面采用现代化的设计风格：
 * - 渐变色标题栏
 * - 圆角按钮
 * - 悬停效果
 * - 分区边框
 * - 合理的间距和布局
 */
public class TaskEditDialog extends JDialog {

    @Serial
    private static final long serialVersionUID = 1L;

    /** 界面颜色常量 */
    /**
     * 标题栏渐变起始颜色
     */
    private static final Color HEADER_GRADIENT_START = new Color(65, 105, 225);
    /**
     * 标题栏渐变结束颜色
     */
    private static final Color HEADER_GRADIENT_END = new Color(100, 149, 237);
    /**
     * 面板背景色
     */
    private static final Color PANEL_BACKGROUND = new Color(245, 245, 250);
    /**
     * 边框颜色
     */
    private static final Color BORDER_COLOR = new Color(210, 210, 210);
    /**
     * 按钮背景色
     */
    private static final Color BUTTON_BACKGROUND = new Color(70, 130, 180);
    /**
     * 按钮悬停颜色
     */
    private static final Color BUTTON_HOVER = new Color(30, 144, 255);
    /**
     * 按钮文字颜色
     */
    private static final Color BUTTON_TEXT = Color.WHITE;

    /**
     * 任务管理服务
     */
    private AutoTaskService taskService;

    /**
     * 当前正在编辑的任务对象
     */
    private AutoTask currentTask;

    /**
     * 任务名称输入框
     */
    private JTextField nameField;

    /**
     * 启动文件路径输入框
     */
    private JTextField pathField;

    /**
     * 步骤列表控件
     */
    private JList<String> stepList;

    /**
     * 步骤列表数据模型
     */
    private DefaultListModel<String> stepListModel;

    /**
     * 保存成功后的回调函数
     */
    private Runnable saveCallback;

    /**
     * 启动等待时间输入框
     */
    private JSpinner waitTimeSpinner;

    /**
     * 构造函数 - 创建新任务
     *
     * @param parent       父窗口
     * @param taskService  任务服务
     * @param saveCallback 保存成功后的回调函数
     */
    public TaskEditDialog(JFrame parent, AutoTaskService taskService, Runnable saveCallback) {
        super(parent, "编辑自动任务", true);
        this.taskService = taskService;
        this.saveCallback = saveCallback;
        this.currentTask = new AutoTask();

        initComponents();

        setSize(720, 700);  // 增加宽度和高度
        setLocationRelativeTo(parent);
        setDefaultCloseOperation(DISPOSE_ON_CLOSE);
    }

    /**
     * 构造函数 - 编辑现有任务
     *
     * @param parent       父窗口
     * @param taskService  任务服务
     * @param task         要编辑的任务对象
     * @param saveCallback 保存成功后的回调函数
     */
    public TaskEditDialog(JFrame parent, AutoTaskService taskService, AutoTask task, Runnable saveCallback) {
        super(parent, "编辑自动任务", true);
        this.taskService = taskService;
        this.saveCallback = saveCallback;
        this.currentTask = task;

        initComponents();

        // 填充已有数据
        nameField.setText(task.getName());
        pathField.setText(task.getStartFilePath());
        waitTimeSpinner.setValue(task.getStartupWaitTime());
        updateStepList();

        setSize(720, 700);  // 增加宽度和高度
        setLocationRelativeTo(parent);
        setDefaultCloseOperation(DISPOSE_ON_CLOSE);
    }

    /**
     * 初始化界面组件
     * <p>
     * 创建并布局主要的界面组件：
     * 1. 主面板：使用BorderLayout布局
     * 2. 标题面板：包含渐变背景和标题文本
     * 3. 内容面板：包含基本信息和步骤列表
     * 4. 按钮面板：包含保存和取消按钮
     */
    private void initComponents() {
        // 设置窗口风格
        try {
            javax.swing.UIManager.setLookAndFeel(javax.swing.UIManager.getSystemLookAndFeelClassName());
        } catch (Exception e) {
            e.printStackTrace();
        }

        // 创建主面板，带白色背景
        JPanel mainPanel = new JPanel(new BorderLayout(0, 0)) {
            @Override
            protected void paintComponent(Graphics g) {
                super.paintComponent(g);
                Graphics2D g2d = (Graphics2D) g.create();
                g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                g2d.setColor(Color.WHITE);
                g2d.fillRect(0, 0, getWidth(), getHeight());
                g2d.dispose();
            }
        };
        mainPanel.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 0));

        // 创建标题面板，带渐变背景
        JPanel titlePanel = new JPanel(new BorderLayout()) {
            @Override
            protected void paintComponent(Graphics g) {
                super.paintComponent(g);
                Graphics2D g2d = (Graphics2D) g.create();
                g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
                GradientPaint gp = new GradientPaint(0, 0, HEADER_GRADIENT_START, 0, getHeight(), HEADER_GRADIENT_END);
                g2d.setPaint(gp);
                g2d.fillRect(0, 0, getWidth(), getHeight());
                g2d.dispose();
            }
        };
        titlePanel.setPreferredSize(new Dimension(720, 60));  // 增加宽度

        // 创建标题标签
        JLabel titleLabel = new JLabel("任务设置");
        titleLabel.setFont(new Font("微软雅黑", Font.BOLD, 18));
        titleLabel.setForeground(Color.WHITE);
        titleLabel.setBorder(BorderFactory.createEmptyBorder(0, 20, 0, 0));
        titlePanel.add(titleLabel, BorderLayout.WEST);

        // 添加标题面板
        mainPanel.add(titlePanel, BorderLayout.NORTH);

        // 创建内容面板
        JPanel contentPanel = new JPanel();
        contentPanel.setLayout(new BoxLayout(contentPanel, BoxLayout.Y_AXIS));
        contentPanel.setBackground(PANEL_BACKGROUND);
        contentPanel.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20));

        // 创建基本信息面板
        JPanel basicInfoPanel = createBasicInfoPanel();

        // 创建步骤列表面板
        JPanel stepsPanel = createStepsPanel();

        // 创建步骤操作按钮面板
        JPanel stepButtonsPanel = createStepButtonsPanel();

        // 添加到内容面板
        contentPanel.add(basicInfoPanel);
        contentPanel.add(Box.createRigidArea(new Dimension(0, 15)));
        contentPanel.add(stepsPanel);
        contentPanel.add(Box.createRigidArea(new Dimension(0, 5)));
        contentPanel.add(stepButtonsPanel);

        // 创建按钮面板
        JPanel buttonPanel = createButtonPanel();

        // 添加到主面板
        mainPanel.add(contentPanel, BorderLayout.CENTER);
        mainPanel.add(buttonPanel, BorderLayout.SOUTH);

        // 设置主面板
        setContentPane(mainPanel);
    }

    /**
     * 创建基本信息面板
     * <p>
     * 包含以下组件：
     * - 任务名称输入框
     * - 启动文件路径输入框
     * - 文件浏览按钮
     * - 启动等待时间输入框
     * <p>
     * 使用GridBagLayout布局，确保组件对齐和合适的间距
     *
     * @return 配置好的基本信息面板
     */
    private JPanel createBasicInfoPanel() {
        JPanel panel = new JPanel(new GridBagLayout());
        panel.setBackground(PANEL_BACKGROUND);
        panel.setBorder(StepDialogUIUtil.createSectionBorder("基本信息", BORDER_COLOR, HEADER_GRADIENT_START));
        panel.setMaximumSize(new Dimension(Integer.MAX_VALUE, 200));
        panel.setPreferredSize(new Dimension(Integer.MAX_VALUE, 200));

        GridBagConstraints gbc = new GridBagConstraints();
        gbc.insets = new Insets(5, 5, 5, 5);
        gbc.fill = GridBagConstraints.HORIZONTAL;

        // 任务名称
        gbc.gridx = 0;
        gbc.gridy = 0;
        gbc.gridwidth = 1;
        gbc.weightx = 0;
        JLabel nameLabel = new JLabel("任务名称:");
        nameLabel.setFont(new Font("微软雅黑", Font.PLAIN, 14));
        panel.add(nameLabel, gbc);

        nameField = new JTextField(20);
        nameField.setFont(new Font("微软雅黑", Font.PLAIN, 14));
        nameField.setPreferredSize(new Dimension(300, 35));
        nameField.setBorder(BorderFactory.createCompoundBorder(
                BorderFactory.createLineBorder(BORDER_COLOR),
                BorderFactory.createEmptyBorder(5, 7, 5, 7)));
        gbc.gridx = 1;
        gbc.gridy = 0;
        gbc.gridwidth = 2;
        gbc.weightx = 1.0;
        panel.add(nameField, gbc);

        // 启动文件路径
        gbc.gridx = 0;
        gbc.gridy = 1;
        gbc.gridwidth = 1;
        gbc.weightx = 0;
        JLabel pathLabel = new JLabel("启动文件:");
        pathLabel.setFont(new Font("微软雅黑", Font.PLAIN, 14));
        panel.add(pathLabel, gbc);

        pathField = new JTextField(20);
        pathField.setFont(new Font("微软雅黑", Font.PLAIN, 14));
        pathField.setPreferredSize(new Dimension(300, 35));
        pathField.setBorder(BorderFactory.createCompoundBorder(
                BorderFactory.createLineBorder(BORDER_COLOR),
                BorderFactory.createEmptyBorder(5, 7, 5, 7)));
        gbc.gridx = 1;
        gbc.gridy = 1;
        gbc.gridwidth = 1;
        gbc.weightx = 1.0;
        panel.add(pathField, gbc);

        JButton browseBtn = createStyledButton("浏览...");
        browseBtn.setPreferredSize(new Dimension(80, 35));
        browseBtn.addActionListener(this::onBrowseButtonClicked);
        gbc.gridx = 2;
        gbc.gridy = 1;
        gbc.gridwidth = 1;
        gbc.weightx = 0;
        panel.add(browseBtn, gbc);

        // 启动等待时间
        gbc.gridx = 0;
        gbc.gridy = 2;
        gbc.gridwidth = 1;
        gbc.weightx = 0;
        JLabel waitTimeLabel = new JLabel("启动等待时间(秒):");
        waitTimeLabel.setFont(new Font("微软雅黑", Font.PLAIN, 14));
        panel.add(waitTimeLabel, gbc);

        waitTimeSpinner = new JSpinner(new javax.swing.SpinnerNumberModel(2, 1, 30, 1));
        waitTimeSpinner.setFont(new Font("微软雅黑", Font.PLAIN, 14));
        waitTimeSpinner.setPreferredSize(new Dimension(60, 35));
        javax.swing.JSpinner.NumberEditor editor = new javax.swing.JSpinner.NumberEditor(waitTimeSpinner, "#");
        waitTimeSpinner.setEditor(editor);

        // 使用面板包装spinner以控制其在父容器中的对齐方式
        JPanel spinnerWrapPanel = new JPanel(new FlowLayout(FlowLayout.LEFT, 0, 0));
        spinnerWrapPanel.setBackground(PANEL_BACKGROUND);
        spinnerWrapPanel.add(waitTimeSpinner);

        gbc.gridx = 1;
        gbc.gridy = 2;
        gbc.gridwidth = 2;
        gbc.weightx = 1.0;
        panel.add(spinnerWrapPanel, gbc);

        return panel;
    }

    /**
     * 创建步骤列表面板
     * <p>
     * 创建一个包含JList的面板，用于显示所有任务步骤。
     * 列表支持单选，具有固定的行高和自定义字体。
     * 每个步骤显示其名称和具体配置信息。
     *
     * @return 配置好的步骤列表面板
     */
    private JPanel createStepsPanel() {
        JPanel panel = new JPanel(new BorderLayout(10, 10));
        panel.setBackground(PANEL_BACKGROUND);
        panel.setBorder(StepDialogUIUtil.createSectionBorder("操作步骤", BORDER_COLOR, HEADER_GRADIENT_START));
        panel.setMaximumSize(new Dimension(Integer.MAX_VALUE, 300));
        panel.setPreferredSize(new Dimension(680, 300));

        // 创建步骤列表
        stepListModel = new DefaultListModel<>();
        stepList = new JList<>(stepListModel);
        stepList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
        stepList.setFont(new Font("微软雅黑", Font.PLAIN, 14));
        stepList.setFixedCellHeight(30);

        JScrollPane scrollPane = new JScrollPane(stepList);
        scrollPane.setBorder(BorderFactory.createLineBorder(BORDER_COLOR));

        panel.add(scrollPane, BorderLayout.CENTER);

        return panel;
    }

    /**
     * 创建步骤操作按钮面板
     * <p>
     * 创建包含所有步骤操作按钮的面板：
     * - 添加步骤：打开步骤编辑对话框创建新步骤
     * - 编辑步骤：编辑选中的步骤
     * - 删除步骤：删除选中的步骤
     * - 上移/下移：调整步骤顺序
     * <p>
     * 所有按钮都使用统一的样式，包括圆角、渐变色和悬停效果
     *
     * @return 配置好的按钮面板
     */
    private JPanel createStepButtonsPanel() {
        JPanel panel = new JPanel();
        panel.setLayout(new FlowLayout(FlowLayout.CENTER, 5, 5)); // 使用FlowLayout并减小间距
        panel.setBackground(PANEL_BACKGROUND);
        panel.setBorder(BorderFactory.createEmptyBorder(5, 0, 5, 0));
        panel.setMaximumSize(new Dimension(Integer.MAX_VALUE, 50));

        JButton addButton = createStyledButton("添加步骤");
        addButton.addActionListener(e -> onAddStepButtonClicked());

        JButton editButton = createStyledButton("编辑步骤");
        editButton.addActionListener(e -> onEditStepButtonClicked());

        JButton deleteButton = createStyledButton("删除步骤");
        deleteButton.addActionListener(e -> onRemoveStepButtonClicked());

        JButton moveUpButton = createStyledButton("上移");
        moveUpButton.addActionListener(e -> onMoveUpButtonClicked());

        JButton moveDownButton = createStyledButton("下移");
        moveDownButton.addActionListener(e -> onMoveDownButtonClicked());

        panel.add(addButton);
        panel.add(editButton);
        panel.add(deleteButton);
        panel.add(moveUpButton);
        panel.add(moveDownButton);

        return panel;
    }

    /**
     * 创建底部按钮面板
     * <p>
     * 创建包含保存和取消按钮的面板。
     * 使用FlowLayout布局，按钮靠右对齐。
     *
     * @return 配置好的按钮面板
     */
    private JPanel createButtonPanel() {
        JPanel panel = new JPanel(new FlowLayout(FlowLayout.RIGHT, 15, 15));
        panel.setBackground(Color.WHITE);
        panel.setBorder(BorderFactory.createMatteBorder(1, 0, 0, 0, BORDER_COLOR));

        JButton cancelButton = createStyledButton("取消");
        cancelButton.addActionListener(e -> dispose());

        JButton saveButton = createStyledButton("保存");
        saveButton.addActionListener(e -> onSaveButtonClicked());

        panel.add(cancelButton);
        panel.add(saveButton);

        return panel;
    }

    /**
     * 创建带样式的按钮
     * <p>
     * 创建一个自定义外观的JButton：
     * - 圆角边框
     * - 渐变背景色
     * - 鼠标悬停效果
     * - 点击效果
     *
     * @param text 按钮文本
     * @return 配置好的按钮
     */
    private JButton createStyledButton(String text) {
        JButton button = new JButton(text) {
            @Override
            protected void paintComponent(Graphics g) {
                Graphics2D g2 = (Graphics2D) g.create();
                g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

                if (getModel().isPressed()) {
                    g2.setColor(BUTTON_BACKGROUND.darker());
                } else if (getModel().isRollover()) {
                    g2.setColor(BUTTON_HOVER);
                } else {
                    g2.setColor(BUTTON_BACKGROUND);
                }

                g2.fillRoundRect(0, 0, getWidth(), getHeight(), 8, 8);
                g2.setColor(BUTTON_TEXT);

                int textWidth = g2.getFontMetrics().stringWidth(getText());
                int textHeight = g2.getFontMetrics().getHeight();
                g2.drawString(getText(), (getWidth() - textWidth) / 2,
                        (getHeight() - textHeight) / 2 + g2.getFontMetrics().getAscent());

                g2.dispose();
            }
        };

        button.setFont(new Font("微软雅黑", Font.BOLD, 14));
        button.setForeground(BUTTON_TEXT);
        button.setBackground(BUTTON_BACKGROUND);
        button.setFocusPainted(false);
        button.setBorderPainted(false);
        button.setContentAreaFilled(false);
        button.setCursor(new Cursor(Cursor.HAND_CURSOR));

        return button;
    }


    /**
     * 更新步骤列表显示
     * <p>
     * 根据当前任务中的步骤更新列表显示。
     * 每个步骤显示以下信息：
     * 1. 序号和名称
     * 2. 根据步骤类型显示不同的配置信息：
     * - 快捷键：显示快捷键组合
     * - 坐标：显示坐标点和是否双击
     * - 粘贴：显示固定值或动态值名称
     */
    private void updateStepList() {
        stepListModel.clear();

        int index = 0;
        for (Step step : currentTask.getSteps()) {
            StringBuilder sb = new StringBuilder();
            sb.append(index + 1).append(". ").append(step.getName());

            if (step.getActionType() == Step.ActionType.SHORTCUT) {
                sb.append(" [快捷键: ").append(step.getShortcut()).append("]");
            } else if (step.getActionType() == Step.ActionType.COORDINATE) {
                if (step.getCoordinate() != null) {
                    Point p = step.getCoordinate();
                    sb.append(" [坐标: (").append(p.x).append(", ").append(p.y).append(")");
                    if (step.isDoubleClick()) {
                        sb.append(", 双击");
                    }
                    sb.append("]");
                } else {
                    sb.append(" [坐标未设置]");
                }
            } else if (step.getActionType() == Step.ActionType.PASTE) {
                if (step.getPasteValueType() == Step.PasteValueType.FIXED) {
                    String value = step.getPasteFixedValue();
                    if (value != null && value.length() > 20) {
                        value = value.substring(0, 17) + "...";
                    }
                    sb.append(" [粘贴固定值: ").append(value).append("]");
                } else {
                    sb.append(" [粘贴动态值: ").append(step.getPasteDynamicName()).append("]");
                }
            }

            stepListModel.addElement(sb.toString());
            index++;
        }
    }

    /**
     * 浏览按钮点击事件处理
     * <p>
     * 打开文件选择对话框，让用户选择启动文件。
     * 仅允许选择.exe和.lnk文件。
     *
     * @param e 事件对象
     */
    private void onBrowseButtonClicked(ActionEvent e) {
        JFileChooser fileChooser = new JFileChooser();
        fileChooser.setFileFilter(new FileNameExtensionFilter("可执行文件 (*.exe, *.lnk)", "exe", "lnk"));
        int result = fileChooser.showOpenDialog(this);
        if (result == JFileChooser.APPROVE_OPTION) {
            File file = fileChooser.getSelectedFile();
            pathField.setText(file.getAbsolutePath());
        }
    }

    /**
     * 处理"添加步骤"按钮点击事件
     * <p>
     * 打开步骤编辑对话框，允许用户创建一个新步骤。
     * 步骤创建成功后，添加到任务的步骤列表中。
     */
    private void onAddStepButtonClicked() {
        StepDialog dialog = new StepDialog(this, "添加步骤");
        // 使用对话框管理器显示对话框
        DialogManager.getInstance().showDialog(dialog, this);

        Step newStep = dialog.getStep();
        if (newStep != null) {
            currentTask.addStep(newStep);
            updateStepList();
        }
    }

    /**
     * 处理"编辑步骤"按钮点击事件
     * <p>
     * 打开步骤编辑对话框，允许用户编辑选中的步骤。
     * 如果没有选中步骤，提示用户先选择。
     * 步骤编辑成功后，更新步骤列表。
     */
    private void onEditStepButtonClicked() {
        int selectedIndex = stepList.getSelectedIndex();
        if (selectedIndex == -1) {
            JOptionPane.showMessageDialog(
                    this,
                    "请先从列表中选择要编辑的步骤。",
                    "请选择步骤",
                    JOptionPane.INFORMATION_MESSAGE
            );
            return;
        }

        // 获取选中的步骤
        Step step = currentTask.getSteps().get(selectedIndex);

        // 创建编辑对话框
        StepDialog dialog = new StepDialog(this, "编辑步骤", step);

        // 使用对话框管理器显示对话框
        DialogManager.getInstance().showDialog(dialog, this);

        // 如果用户确认了编辑，更新步骤列表
        Step editedStep = dialog.getStep();
        if (editedStep != null) {
            currentTask.getSteps().set(selectedIndex, editedStep);
            updateStepList();
        }
    }

    /**
     * 删除步骤按钮点击事件处理
     * <p>
     * 删除选中的步骤。
     * 如果未选中步骤，显示提示信息。
     * 删除前会显示确认对话框。
     */
    private void onRemoveStepButtonClicked() {
        int selectedIndex = stepList.getSelectedIndex();
        if (selectedIndex == -1) {
            JOptionPane.showMessageDialog(this,
                    "请先选择要删除的步骤",
                    "提示",
                    JOptionPane.INFORMATION_MESSAGE);
            return;
        }

        int option = JOptionPane.showConfirmDialog(this,
                "确认删除选中的步骤吗？",
                "确认删除",
                JOptionPane.YES_NO_OPTION,
                JOptionPane.WARNING_MESSAGE);

        if (option == JOptionPane.YES_OPTION) {
            currentTask.getSteps().remove(selectedIndex);
            updateStepList();
        }
    }

    /**
     * 保存按钮点击事件处理
     * <p>
     * 保存当前任务配置。
     * 执行流程：
     * 1. 验证任务名称
     * 2. 检查名称是否重复（新建任务时）
     * 3. 验证启动文件路径
     * 4. 检查步骤配置
     * 5. 保存任务
     * 6. 调用保存成功回调
     */
    private void onSaveButtonClicked() {
        String name = nameField.getText().trim();
        String path = pathField.getText().trim();
        int waitTime = 0;
        try {
            waitTime = waitTimeSpinner.getValue() == null ? 0 : (Integer) waitTimeSpinner.getValue();
        } catch (Exception ex) {
            waitTime = 0;
        }
        // 验证输入
        if (name.isEmpty()) {
            JOptionPane.showMessageDialog(this,
                    "请输入任务名称",
                    "输入错误",
                    JOptionPane.ERROR_MESSAGE);
            return;
        }
        // 启动文件和等待时间可以为空，不做必填校验
        // 检查名称是否重复（仅在新建任务时检查）
        if (currentTask.getName() == null || !currentTask.getName().equals(name)) {
            AutoTask existingTask = taskService.loadTask(name);
            if (existingTask != null) {
                int option = JOptionPane.showConfirmDialog(this,
                        "任务名称已存在，是否覆盖？",
                        "名称重复",
                        JOptionPane.YES_NO_OPTION);
                if (option != JOptionPane.YES_OPTION) {
                    return;
                }
            }
        }
        // 如果填写了启动文件，校验文件存在
        if (!path.isEmpty()) {
            File file = new File(path);
            if (!file.exists() || !file.isFile()) {
                int option = JOptionPane.showConfirmDialog(this,
                        "启动文件不存在，是否继续？",
                        "文件不存在",
                        JOptionPane.YES_NO_OPTION);
                if (option != JOptionPane.YES_OPTION) {
                    return;
                }
            }
        }
        // 更新任务数据
        currentTask.setName(name);
        currentTask.setStartFilePath(path);
        currentTask.setStartupWaitTime(waitTime);
        // 保存任务
        try {
            taskService.saveTask(currentTask);
            if (saveCallback != null) {
                saveCallback.run();
            }
            dispose();
        } catch (Exception e) {
            JOptionPane.showMessageDialog(this,
                    "保存任务失败: " + e.getMessage(),
                    "保存错误",
                    JOptionPane.ERROR_MESSAGE);
        }
    }

    /**
     * 上移按钮点击事件处理
     * <p>
     * 将选中的步骤向上移动一位。
     * 如果步骤已经在最顶部或未选中步骤，显示提示信息。
     */
    private void onMoveUpButtonClicked() {
        int selectedIndex = stepList.getSelectedIndex();
        if (selectedIndex == -1) {
            JOptionPane.showMessageDialog(this,
                    "请先选择要移动的步骤",
                    "提示",
                    JOptionPane.INFORMATION_MESSAGE);
            return;
        }

        if (selectedIndex == 0) {
            JOptionPane.showMessageDialog(this,
                    "该步骤已经在最顶部",
                    "提示",
                    JOptionPane.INFORMATION_MESSAGE);
            return;
        }

        // 交换步骤位置
        java.util.List<Step> steps = currentTask.getSteps();
        Step step = steps.get(selectedIndex);
        steps.set(selectedIndex, steps.get(selectedIndex - 1));
        steps.set(selectedIndex - 1, step);

        // 更新列表显示并保持选中状态
        updateStepList();
        stepList.setSelectedIndex(selectedIndex - 1);
    }

    /**
     * 下移按钮点击事件处理
     * <p>
     * 将选中的步骤向下移动一位。
     * 如果步骤已经在最底部或未选中步骤，显示提示信息。
     */
    private void onMoveDownButtonClicked() {
        int selectedIndex = stepList.getSelectedIndex();
        if (selectedIndex == -1) {
            JOptionPane.showMessageDialog(this,
                    "请先选择要移动的步骤",
                    "提示",
                    JOptionPane.INFORMATION_MESSAGE);
            return;
        }

        if (selectedIndex == currentTask.getSteps().size() - 1) {
            JOptionPane.showMessageDialog(this,
                    "该步骤已经在最底部",
                    "提示",
                    JOptionPane.INFORMATION_MESSAGE);
            return;
        }

        // 交换步骤位置
        java.util.List<Step> steps = currentTask.getSteps();
        Step step = steps.get(selectedIndex);
        steps.set(selectedIndex, steps.get(selectedIndex + 1));
        steps.set(selectedIndex + 1, step);

        // 更新列表显示并保持选中状态
        updateStepList();
        stepList.setSelectedIndex(selectedIndex + 1);
    }

    /**
     * 获取当前编辑的任务对象
     *
     * @return 任务对象
     */
    public AutoTask getTask() {
        return currentTask;
    }
}
